package com.jing.shop.controller;

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.jing.common.core.domain.R;
import com.jing.shop.domain.vo.PmsProductAttrRelVO;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;
import java.util.stream.Collectors;

@RestController
public class Test {

    @PostMapping("test")
    public R test(String[] args) {
        String str = "[\n" +
                "\t{\n" +
                "\t\t\"cid\": 1,\n" +
                "\t\t\"attrName\": \"黑色\"\n" +
                "\t}\n" +
                "\t{\n" +
                "\t\t\"cid\": 2,\n" +
                "\t\t\"attrName\": \"M\"\n" +
                "\t}\n" +
                "\t{\n" +
                "\t\t\"cid\": 1,\n" +
                "\t\t\"attrName\": \"红色\"\n" +
                "\t}\n" +
                "\t{\n" +
                "\t\t\"cid\": 2,\n" +
                "\t\t\"attrName\": \"X\"\n" +
                "\t}\n" +
                "]\n" +
                "\n";
        List<PmsProductAttrRelVO> relVos = JSONArray.parseArray(str, PmsProductAttrRelVO.class);

        Map<String, List<PmsProductAttrRelVO>> groupedByCid = relVos.stream()
                .collect(Collectors.groupingBy(
                        map -> String.valueOf(map.getCid()), // 分组键
                        Collectors.toList() // 收集器
                ));
        //TODO  转换
        Set<Integer> uniqueCids = new HashSet<>(groupedByCid.keySet().stream()
                .map(Integer::parseInt)
                .collect(Collectors.toList()));

        // 获取所有可能的组合
        List<Map<String, String>> combinations = new ArrayList<>();
        List<List<String>> cidValues = uniqueCids.stream()
                .map(cid -> groupedByCid.getOrDefault(String.valueOf(cid), Collections.emptyList())
                        .stream()
                        .map(PmsProductAttrRelVO::getAttrName)
                        .collect(Collectors.toList()))
                .collect(Collectors.toList());

        // 使用笛卡尔积生成所有组合
        cartesianProductIterative(cidValues).forEach(combination -> {
            Map<String, String> result = new LinkedHashMap<>();
            for (int i = 0; i < combination.size(); i++) {
                result.put(String.valueOf(uniqueCids.toArray(new Integer[0])[i]), combination.get(i));
            }
            combinations.add(result);
        });

        // 输出结果
        System.out.println(JSONObject.toJSONString(combinations));
        return R.ok(combinations);
    }

    // 计算笛卡尔积的辅助方法
    public static List<List<String>> cartesianProductIterative(List<List<String>> lists) {
        if (lists == null || lists.isEmpty()) {
            return Collections.emptyList();
        }
        // 初始化结果列表，其中包含一个空的列表（作为开始点）
        List<List<String>> result = new ArrayList<>();
        result.add(new ArrayList<>());
        // 遍历每个列表
        for (List<String> list : lists) {
            // 如果当前列表为空，则不需要进一步处理
            if (list.isEmpty()) {
                continue;
            }
            // 临时存储新的结果
            List<List<String>> newResult = new ArrayList<>();
            // 遍历当前结果列表中的每个组合
            for (List<String> combination : result) {
                // 遍历当前列表中的每个元素
                for (String element : list) {
                    // 复制当前组合并添加新元素
                    List<String> newCombination = new ArrayList<>(combination);
                    newCombination.add(element);
                    // 将新的组合添加到新的结果列表中
                    newResult.add(newCombination);
                }
            }
            // 用新的结果列表替换当前结果列表
            result = newResult;
        }
        return result;
    }

}
